import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:alfred/alfred.dart';
import 'package:event_bus/event_bus.dart';
import 'package:get/get.dart';
import 'package:shimo_app/bus/struct/boardStatus.dart';
import 'package:shimo_app/bus/struct/error.dart';
import 'package:shimo_app/bus/struct/task_progress.dart';
import 'package:shimo_app/services/db_service.dart';
import 'package:shimo_app/utils/utils.dart';

import '../bus/bus.dart';
import '../bus/struct/task_result.dart';
import '../remote/server.dart';

/// 设备服务类 - 管理硬件设备通信和业务逻辑的核心服务
///
/// 继承自GetxService，表示这是一个全局单例服务
class DeviceService extends GetxService {
  late Bus _bus; // 总线通信实例
  String host = ""; // 主机IP地址
  late Timer _serialOpenStateTimer; // 串口状态检测定时器
  List<Function> _listeners = []; // 连接状态监听器列表
  bool _serialPortConnected = false; // 串口连接状态
  int _busState = 0; // 总线状态
  late DbService db; // 数据库服务实例
  List<int> sampleSize = [6, 6]; // 样本尺寸配置 [通道1, 通道2]
  EventBus eventBus = EventBus(); // 应用内部事件总线
  final RemoteServer _server = RemoteServer(); // 远程服务器实例
  static const String _adjustmentKey = "calibration*.*"; // 校准数据存储键前缀
  User? currentUser; // 当前登录用户
  bool deviceWorking = false; // 设备工作状态标志
  int channelMode = 1; // 通道模式 (1=单通道, 2=双通道)
  String? logPath; // 日志文件路径
  String? funcPath; // 功能文件路径

  /// 初始化设备服务
  Future<DeviceService> init() async {
    // 获取本机IP地址
    final networks = await NetworkInterface.list();
    for (var i in networks) {
      for (var j in i.addresses) {
        if (i.name == "WLAN" && j.address.startsWith("192.168")) {
          host = j.address; // 使用WLAN网络的192.168.x.x地址
          break;
        }
      }
    }

    // 初始化总线实例
    _bus = Bus();

    // 设置串口状态检测定时器（每秒检测一次）
    _serialOpenStateTimer = Timer.periodic(1.seconds, (timer) {
      // 检查状态是否有变化
      if (_serialPortConnected == _bus.serialPortOpened &&
          _busState == _bus.busState) {
        return; // 状态未变化，直接返回
      }

      // 更新状态并通知所有监听器
      _serialPortConnected = _bus.serialPortOpened;
      // _busState = _bus.busState;
      for (var i in _listeners) {
        i(_bus.serialPortOpened, _bus.busState);
      }
    });

    // 设置总线事件监听器
    _bus.setBoardStatusListener(onBoardStatusChange);
    _bus.setTaskProgressListener(onTaskProgress);
    _bus.setErrorListener(onErrorListener);
    _bus.setLogListener((e) => eventBus.fire(LogEvent(e.content)));

    // 获取数据库服务实例
    db = Get.find<DbService>();

    // 监听设备工作状态事件
    eventBus.on<DeviceWorkEvent>().listen((event) {
      deviceWorking = event.isWorking;
    });

    // 从数据库获取配置路径
    logPath = db.getValue("logPath");
    funcPath = db.getValue("funcPath");

    return this;
  }

  @override
  void onInit() {
    // 启动远程服务器，注册总线处理函数
    _server.start({
      "bus": onBusHandler, // 总线相关命令处理
    });
    super.onInit();
  }

  @override
  void onClose() {
    // 清理资源
    _serialOpenStateTimer.cancel(); // 停止定时器
    if (_bus.serialPortOpened) {
      _bus.close(); // 关闭总线连接
    }
    eventBus.destroy(); // 销毁事件总线
    _server.stop(); // 停止远程服务器
    super.onClose();
  }

  /// 获取串口连接状态
  bool get serialPortConnected {
    return _serialPortConnected;
  }

  /// 获取总线状态
  int get busState {
    return _busState;
  }

  /// 启动总线连接
  Future<bool> startBus(String name) async {
    return _bus.start(name, channelMode);
  }

  /// 关闭总线连接
  void closeBus() async {
    return _bus.close();
  }

  /// 获取可用串口列表
  List<Map<String, String>> getPorts() {
    return _bus.getSerialPorts();
  }

  /// 添加总线连接状态监听器
  void setBusConnectedListener(Function(bool, int) listener) {
    _listeners.add(listener);
  }

  /// 任务进度事件处理
  void onTaskProgress(TaskProgress progress) {
    eventBus.fire(TaskEvent(progress));
  }

  /// 错误事件处理
  void onErrorListener(List<SetComponentError> errors) {
    print("刷新异常:${errors.length}");
    eventBus.fire(ErrorEvent(errors));
  }

  /// 电路板状态变化处理
  void onBoardStatusChange(BoardStatus status) async {
    if (status == BoardStatus.BOARD_AFTERBOOT) {
      // 设备启动后，恢复保存的校准参数
      final savedAdjustmentKeys = db.getKeysByHeader(_adjustmentKey);
      print("获取adj keys:${savedAdjustmentKeys}");

      for (var i in savedAdjustmentKeys) {
        final value = db.getValue<int>(i);
        print("获取存储数据:$value");
        final key = i.split(_adjustmentKey)[1]; // 提取参数名
        await _bus.setAdjustment({key: value ?? 0}); // 设置校准参数
      }
    }

    if (status == BoardStatus.BOARD_INIT) {
      // 初始化状态处理（当前为空）
    }
  }

  // 服务器总线操作状态标志
  bool _serverBusRunning = false;
  bool _actionResult = false;

  /// 总线命令HTTP请求处理
  void onBusHandler(HttpRequest req, HttpResponse res) async {
    final cmd = req.params["cmd"]; // 获取命令参数

    if (cmd == "state") {
      // 查询状态命令
      if (_serverBusRunning) {
        res.json(_wrapResponse(true, message: {"state": "onAction"}));
        return;
      }
      if (!_serverBusRunning) {
        res.json(_wrapResponse(true,
            message: {"state": "idle", "result": _actionResult}));
        return;
      }
    }

    if (cmd == "adjustment") {
      // 设置校准参数命令
      final id = req.params['id'];
      final value = req.params['value'];
      final r = await _bus.setAdjustment({id: value});
      res.json(_wrapResponse(r, errMsg: r ? "" : "总线异常"));
      return;
    }

    if (cmd == "sensor") {
      // 读取传感器数值命令
      final componentId = req.params['componentId'];
      final sensorId = req.params["sensorId"];
      final r = await _bus.getSensorValue(componentId, sensorId);
      res.json(_wrapResponse(true, message: {"value": r}));
    }

    // 检查是否正在执行其他操作
    if (_serverBusRunning) {
      res.json(_wrapResponse(true, errMsg: "运行中"));
      return;
    }

    if (cmd == "action") {
      // 执行组件动作命令
      final componentId = req.params['componentId'];
      final actionId = req.params["actionId"];
      final arg = req.params["arg"];

      // 使用微任务异步执行，避免阻塞HTTP响应
      Future.microtask(() async {
        _serverBusRunning = true;
        _actionResult = await _bus.componentAction(componentId, actionId, arg);
        _serverBusRunning = false;
      });

      res.json(_wrapResponse(true));
      return;
    }
  }

  /// 包装HTTP响应数据
  Map<String, dynamic> _wrapResponse(bool stateOk,
      {dynamic message, String errMsg = ""}) {
    return {"result": stateOk ? "OK" : errMsg, "data": message};
  }

  // === 硬件组件ID定义 ===
  int get armComponentId => 101; // 机械臂组件ID
  int get waterSupportComponentId => 141; // 水支撑组件ID
  int get sampleBaseId => 121; // 样本基座ID
  int get heaterId => 161; // 加热器ID
  int get absorberId => 181; // 吸收器ID

  // === 动作命令定义 ===
  int get absorbAction => 1; // 吸收动作
  int get pumpAction => 1; // 泵动作
  int get pumpCalibrationAction => 3; // 泵校准动作
  int get xMoveAction => 2; // X轴移动动作
  int get xMoveHome => 0; // X轴归零
  int get yMoveHome => 1; // Y轴归零
  int get yMoveAction => 3; // Y轴移动动作
  int get initAction => 5; // 初始化动作
  int get clear => 1; // 清除动作
  int get lift => 0; // 抬升动作
  int get down => 1; // 下降动作
  int get GetSensorValuelift => 2; // 抬升时获取传感器值
  int get GetSensorValuedown => 3; // 下降时获取传感器值
  int get add => 2; // 添加动作
  int get shake => 1; // 摇动动作
  int get cooling => 2; // 冷却动作
  int get switchValve => 0; // 切换阀门
  int get heatOn => 0; // 加热开启
  int get heatOn1 => 2; // 加热开启1
  int get heatOff => 1; // 加热关闭
  int get heatOff1 => 3; // 加热关闭1
  int get moveArm => 4; // 移动机械臂

  // === 传感器ID定义 ===
  int get distantSensorId => 0; // 距离传感器
  int get temperatureSensor => 0; // 温度传感器
  int get temperatureSensor1 => 2; // 温度传感器1
  int get powerSensor => 1; // 功率传感器
  int get powerSensor1 => 3; // 功率传感器1
  int get ultrasonicSensor1 => 0; // 超声波传感器1
  int get ultrasonicSensor2 => 0; // 超声波传感器2
  int get remainingtime => 0; // 剩余时间传感器
  int get remainingtime1 => 1; // 剩余时间传感器1
  int get armPositionXSensor => 1; // 机械臂X轴位置传感器
  int get armPositionYSensor => 2; // 机械臂Y轴位置传感器

  /// 用户登录验证
  User? doLogin(String userId, String password) {
    final raw = db.getValue<String>("users");
    List<Map<String, dynamic>> users = [];
    print("users:$raw");

    try {
      users = jsonDecode(raw!).cast<Map<String, dynamic>>();
    } catch (e) {}

    // 查找匹配的用户
    final e = users.firstWhereOrNull((element) =>
        element['id'] == userId && element['password'] == password);

    if (e != null && e['enable']) {
      // 登录成功，创建用户对象
      currentUser = User(
          e['name'],
          e['id'],
          UserPrivilege.values[e['privilege']],
          e['password'],
          e['createdAt'],
          e['enable'],
          e['createdBy']);

      navigator?.pop(Get.context!); // 关闭登录对话框
      return currentUser;
    }
    return null;
  }

  /// 获取校准值
  int getCalibrationValue(String id) {
    return db.getValue<int>("$_adjustmentKey${id}") ?? 0;
  }

  /// 保存校准值
  Future<bool> saveCalibrationValue(String id, int value) async {
    final r = await _bus.setAdjustment({id: value});
    if (!r) return false;
    db.setValue("$_adjustmentKey${id}", value);
    return true;
  }

  /// 获取传感器值（待实现）
  Future<int> getSenSorValue(int component, int id) async {
    return 0;
  }

  /// 部署样本和任务
  Future<bool> deploySamplesAndTasks(
      int containerId, List<bool> samples, List<TaskDeployData> tasks) async {
    print(samples);
    print(tasks);

    // 1. 设置样本配置
    bool result = await _bus.setSample(containerId, samples);
    if (!result) {
      return false;
    }

    // 2. 部署任务
    result = await _bus.deployTask(containerId, tasks);
    if (!result) {
      return false;
    }

    return true;
  }

  /// 初始化电路板
  Future<bool> initBoardAction() async {
    _bus.readyToInit();
    return _bus.initBoard();
  }

  /// 运行任务
  Future<TaskResult> runTask() async {
    return _bus.runTask();
  }

  /// 执行组件动作
  Future<bool> componentAction(int componentId, int actionId, int arg) async {
    return await _bus.componentAction(componentId, actionId, arg);
  }

  /// 中止动作
  Future<bool> abortAction(int containerId, {bool isPause = false}) async {
    return _bus.abortAction(containerId, isPause: isPause);
  }

  /// 恢复任务
  Future<bool> resume() async {
    return _bus.resume();
  }

  /// 获取传感器值
  Future<int> getSensorValue(int componentId, int sensorId) async {
    return _bus.getSensorValue(componentId, sensorId);
  }

  /// 设置调整参数
  Future<bool> setAdjustment(String adjId, int value) async {
    return _bus.setAdjustment({adjId: value});
  }

  /// 添加日志记录（内部方法）
  void _addLog(int containerId, LogType type, String content) {
    eventBus.fire(
        LocalLog(containerId, Utils.getCurrentTimeStamp(), type, content));
  }

  /// 添加系统日志
  void addSystemLog(int containerId, String content) {
    _addLog(containerId, LogType.systemLog, content);
  }

  /// 添加调试日志
  void addDebugLog(int containerId, String content) {
    _addLog(containerId, LogType.debugLog, content);
  }

  /// 添加操作日志
  void addOperationLog(int containerId, String content) {
    _addLog(containerId, LogType.operationLog, content);
  }

  /// 添加错误日志
  void addErrorLog(int containerId, String content) {
    _addLog(containerId, LogType.errorLog, content);
  }
}

// === 事件类定义 ===

/// 任务事件
class TaskEvent {
  TaskProgress event;

  TaskEvent(this.event);
}

/// 错误事件
class ErrorEvent {
  List<SetComponentError> errors;

  ErrorEvent(this.errors);
}

/// 日志事件
class LogEvent {
  String log;

  LogEvent(this.log);
}

/// 日志类型枚举
enum LogType { systemLog, debugLog, operationLog, errorLog }

/// 本地日志记录
class LocalLog {
  int index; // 容器索引
  int time; // 时间戳
  String content; // 日志内容
  LogType type; // 日志类型

  LocalLog(this.index, this.time, this.type, this.content);
}

/// 用户权限枚举
enum UserPrivilege { userExecutor, userAdmin, userSuperAdmin, userTop }

/// 用户信息类
class User {
  final UserPrivilege privilege; // 用户权限
  final String name; // 用户名
  final String id; // 用户ID
  final int createdAt; // 创建时间
  final String password; // 密码
  final bool enable; // 是否启用
  final String createdBy; // 创建者

  /// 转换为JSON格式
  Map<String, dynamic> toJson() {
    return {
      "name": name,
      "id": id,
      "createdAt": createdAt,
      "createdBy": createdBy,
      "enable": enable,
      "password": password,
      "privilege": privilege.index,
    };
  }

  User(
    this.name,
    this.id,
    this.privilege,
    this.password,
    this.createdAt,
    this.enable,
    this.createdBy,
  );
}

/// 设备工作状态事件
class DeviceWorkEvent {
  final bool isWorking;

  DeviceWorkEvent(this.isWorking);
}
